// pages/school/index.js
const { api } = require('../../utils/api');

Page({
  data: {
    isLoading: true,
    currentTab: 'map', // 默认显示地图标签
    mapSubTab: 'heatmap', // 默认显示热力图

    // 排名相关数据
    rankList: [],
    keyword: '',
    pageNum: 1,
    pageSize: 10,
    hasMoreData: true,

    // 学习园地相关数据
    studyGardenId: 1001, // 默认学习园地ID
    comments: [],
    commentPage: 1,
    commentSize: 10,
    isLoadingComments: false,
    hasMoreComments: true,
    // 地图参数
    latitude: 38.0501,  // 更新为石家庄中心区域的纬度
    longitude: 114.5122, // 更新为石家庄中心区域的经度
    markers: [],

    // 地区数据
    regionLevels: ['省份', '城市', '区县'],
    regionLevelIndex: 0,
    totalUsers: 0,
    regionData: [],

    // 地区导航
    currentRegionLevel: 'province', // 当前显示的级别：province, city, district
    currentProvinceName: '',
    currentProvinceId: 0,
    currentCityName: '',
    currentCityId: 0,
    breadcrumbs: [], // 面包屑导航

    // 性别比例数据
    genderData: {
      male: 62,
      female: 38,
      maleCount: 2313,
      femaleCount: 1417,
      total: 3730
    },

    // 环形图样式
    donutStyle: 'background: conic-gradient(#ff3b30 0% 38%, #3a86ff 38% 100%);',


    // 地图数据
    mapCenter: {
      longitude: 116.404,
      latitude: 39.915
    },
    markers: [],
    points: [],

    // 学习心得数据
    comments: [
      {
        id: 1,
        avatar: '/images/avatar1.jpg',
        name: '赵六',
        time: '2023-05-15',
        content: '这个课程非常实用，学到了很多新知识',
        likes: 24,
        liked: false
      },
      {
        id: 2,
        avatar: '/images/avatar2.jpg',
        name: '钱七',
        time: '2023-05-10',
        content: '老师讲解得很清晰，收获很大',
        likes: 18,
        liked: true
      }
    ],
    mapConfig: {
      key: 'XHMBZ-L55CT-XARXX-LCUX7-S7KVJ-JWFAQ', // 更新为用户提供的高德地图key
      referer: '宏益微信小程序'
    }
  },

  onLoad() {
    // 确保从第一页开始加载
    this.setData({
      pageNum: 1,
      keyword: '',
      hasMoreData: true
    });
    this.loadSchoolRanking();
    this.mapCtx = wx.createMapContext('myMap');
    // 立即加载用户热力图，避免首次无数据
    this.loadUserMarkers();
    this.loadSchools();
    // 加载用户列表数据
    this.loadUserList();

    // 获取用户位置权限
    wx.getLocation({
      type: 'gcj02',
      success: (res) => {
        const { latitude, longitude } = res;
        console.log('当前位置:', latitude, longitude);
        this.setData({
          latitude,
          longitude
        });
        // 初始化地图
        this.mapCtx = wx.createMapContext('heatMap');
        // 再次加载用户热力图，确保有数据
        this.loadUserMarkers();
      },
      fail: (err) => {
        console.error('获取位置失败:', err);
        // 即使获取位置失败，也初始化地图
        this.mapCtx = wx.createMapContext('heatMap');
        this.loadUserMarkers();
      }
    });
    // 初始化加载省份数据
    this.loadProvinceData();
  },

  // 下拉刷新
  onPullDownRefresh() {
    if (this.data.currentTab === 'rank') {
      this.refreshRanking().then(() => {
        wx.stopPullDownRefresh();
      });
    } else if (this.data.currentTab === 'study') {
      this.refreshStudyGardenComments().then(() => {
        wx.stopPullDownRefresh();
      });
    } else {
      wx.stopPullDownRefresh();
    }
  },

  // 到底加载更多
  onReachBottom() {
    if (this.data.currentTab === 'rank' && this.data.hasMoreData && !this.data.isLoading) {
      this.loadMoreRanking();
    } else if (this.data.currentTab === 'study' && this.data.hasMoreComments && !this.data.isLoadingComments) {
      this.loadMoreComments();
    }
  },

  // 处理导航栏切换
  switchTab(e) {
    const tab = e.currentTarget.dataset.tab;
    this.setData({
      currentTab: tab
    });
    // 根据不同的tab加载不同的内容
    if (tab === 'rank') {
      this.refreshRanking();
    } else if (tab === 'map') {
      // 每次切换到地图tab都立即加载热力图数据
      this.setData({ mapSubTab: 'heatmap' });
      this.loadUserMarkers();
    } else if (tab === 'study') {
      this.loadStudyGardenComments();
    }
  },

  // 搜索框输入
  onKeywordInput(e) {
    this.setData({
      keyword: e.detail.value
    });
  },

  // 搜索排名
  searchRanking() {
    this.setData({
      pageNum: 1,
      hasMoreData: true,
      rankList: [] // 清空当前排名列表，确保搜索时不会显示旧数据
    }, () => {
      this.loadSchoolRanking();
    });
  },

  // 刷新排名数据
  refreshRanking() {
    this.setData({
      pageNum: 1,
      hasMoreData: true
    });
    return this.loadSchoolRanking();
  },

  // 加载更多排名数据
  loadMoreRanking() {
    if (this.data.hasMoreData && !this.data.isLoading) {
      this.setData({
        pageNum: this.data.pageNum + 1
      }, () => {
        this.loadSchoolRanking(true);
      });
    }
  },

  // 加载学院排名数据
  async loadSchoolRanking(append = false) {
    this.setData({
      isLoading: true
    });

    try {
      // 调用后端 API 获取排名数据
      const result = await api.getSchoolRanking(
        this.data.keyword,
        this.data.pageNum,
        this.data.pageSize
      );

      if (result && (result.code === 0 || result.code === 200)) {
        // 使用result.data.records或result.data.list获取列表数据
        let newList = result.data.records || result.data.list || [];
        // 获取总记录数
        const total = result.data.total || 0;

        // 格式化数据用于显示
        newList = newList.map((item, index) => {
          const score = item.score || item.points || 0;
          // 基于积分计算等级：每50分提升一级
          const calculatedLevel = this.calculateLevel(score);

          return {
            id: item.id,
            name: item.name || '未知用户',
            level: item.level || item.user_level || 0,
            calculatedLevel: calculatedLevel,
            score: score,
            phone: item.phone || '',
            openid: item.openid || '',
            head_url: item.head_url || item.avatar || ''
          };
        });

        // 如果当前页没有数据，且不是第一页，则回到第一页重新加载
        if (newList.length === 0 && this.data.pageNum > 1 && !append) {
          this.setData({
            pageNum: 1
          }, () => {
            this.loadSchoolRanking(false);
          });
          return;
        }

        if (append) {
          // 加载更多，追加数据
          this.setData({
            rankList: [...this.data.rankList, ...newList],
            // 判断是否还有更多数据
            hasMoreData: (this.data.pageNum * this.data.pageSize) < total,
            isLoading: false
          });
        } else {
          // 刷新数据，替换数据
          this.setData({
            rankList: newList,
            // 判断是否还有更多数据
            hasMoreData: (this.data.pageNum * this.data.pageSize) < total,
            isLoading: false
          });
        }
      } else {
        this.setData({ isLoading: false });
        wx.showToast({
          title: result.message || '获取排名数据失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('获取排名数据失败:', error);
      this.setData({ isLoading: false });
      wx.showToast({
        title: '获取排名数据失败，请重试',
        icon: 'none'
      });
    }
  },

  // 根据积分计算等级
  calculateLevel(score) {
    // 基础等级为1
    if (score <= 0) return 0;

    // 每50分提升一级
    return Math.floor(score / 50) + 1;
  },

  // 刷新学习园地评论
  refreshStudyGardenComments() {
    this.setData({
      commentPage: 1,
      hasMoreComments: true
    });
    return this.loadStudyGardenComments();
  },

  // 加载更多评论
  loadMoreComments() {
    if (this.data.hasMoreComments && !this.data.isLoadingComments) {
      this.setData({
        commentPage: this.data.commentPage + 1
      }, () => {
        this.loadStudyGardenComments(true);
      });
    }
  },

  // 加载学习园地评论
  async loadStudyGardenComments(append = false) {
    this.setData({
      isLoadingComments: true
    });
    
    try {
      const result = await api.getStudyGardenComments(
        this.data.studyGardenId,
        this.data.commentPage,
        this.data.commentSize
      );
      
      if (result && (result.code === 0 || result.code === 200)) {
        // 处理评论数据
        const commentData = result.data || {};
        const commentList = commentData.comments || [];
        const total = commentData.total || 0;

        // 计算每条评论的回复数量
        const formattedComments = commentList.map(item => {
          // 添加回复计数
          const replyCount = item.replies ? item.replies.length : 0;
          return {
            ...item,
            replyCount
          };
        });
        
        if (append) {
          // 加载更多，追加数据
          this.setData({
            comments: [...this.data.comments, ...formattedComments],
            hasMoreComments: (this.data.commentPage * this.data.commentSize) < total,
            isLoadingComments: false
          });
        } else {
          // 刷新数据，替换数据
          this.setData({
            comments: formattedComments,
            hasMoreComments: (this.data.commentPage * this.data.commentSize) < total,
            isLoadingComments: false
          });
        }
      } else {
        this.setData({ isLoadingComments: false });
        wx.showToast({
          title: result.message || '获取评论失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('获取评论失败:', error);
      this.setData({ isLoadingComments: false });
      wx.showToast({
        title: '获取评论失败，请重试',
        icon: 'none'
      });
    }
  },

  // 点赞评论
  toggleLike(e) {
    const id = e.currentTarget.dataset.id;
    // 先本地切换UI
    const comments = this.data.comments.map(item => {
      if (item.comment.id === id) {
        const liked = !item.comment.liked;
        const likecount = (item.comment.likecount || 0) + (liked ? 1 : -1);
        return {
          ...item,
          comment: {
            ...item.comment,
            liked,
            likecount: likecount < 0 ? 0 : likecount
          }
        };
      }
      return item;
    });
    this.setData({ comments });

    // 判断是点赞还是取消点赞
    const current = this.data.comments.find(item => item.comment.id === id);
    if (current && !current.comment.liked) {
      // 取消点赞
      api.cancelLikeComment(id).then(res => {
        // 兼容两种数据格式：直接返回业务数据 或 完整wx.request响应
        const apiData = res.statusCode ? res.data : res;
        if (apiData && apiData.code === 200 && (apiData.data === true || apiData.data === 1)) {
          wx.showToast({ title: '已取消点赞', icon: 'none' });
        } else {
          console.log('取消点赞失败返回：', res);
          this.revertLikeStatus(id);
          wx.showToast({ title: (apiData && apiData.message) || '操作失败', icon: 'none' });
        }
      }).catch((err) => {
        console.log('取消点赞异常：', err);
        this.revertLikeStatus(id);
        wx.showToast({ title: '操作失败，请重试', icon: 'none' });
      });
    } else {
      // 点赞
      api.likeComment(id).then(res => {
        // 兼容两种数据格式：直接返回业务数据 或 完整wx.request响应
        const apiData = res.statusCode ? res.data : res;
        if (apiData && apiData.code === 200 && (apiData.data === true || apiData.data === 1)) {
          wx.showToast({ title: '点赞成功', icon: 'success' });
        } else {
          console.log('点赞失败返回：', res);
          this.revertLikeStatus(id);
          wx.showToast({ title: (apiData && apiData.message) || '点赞失败', icon: 'none' });
        }
      }).catch((err) => {
        console.log('点赞异常：', err);
        this.revertLikeStatus(id);
        wx.showToast({ title: '点赞失败，请重试', icon: 'none' });
      });
    }
  },
  
  // 恢复点赞状态（用于API调用失败时）
  revertLikeStatus(id) {
    const comments = this.data.comments.map(item => {
      if (item.comment.id === id) {
        const comment = { ...item.comment };
        const liked = !comment.liked;
        const likecount = (comment.likecount || 0) + (liked ? 1 : -1);
        
        return {
          ...item, 
          comment: {
            ...comment,
            liked,
            likecount: likecount < 0 ? 0 : likecount
          }
        };
      }
      return item;
    });
    
    this.setData({ comments });
  },

  // 显示回复框
  showReply(e) {
    const commentId = e.currentTarget.dataset.id;
    const replyToName = e.currentTarget.dataset.name;
    
    wx.showModal({
      title: `回复 ${replyToName}`,
      placeholderText: '请输入回复内容...',
      editable: true,
      success: (res) => {
        if (res.confirm && res.content) {
          this.postReply(commentId, res.content);
        }
      }
    });
  },
  
  // 发表回复
  async postReply(commentId, content) {
    if (!content.trim()) {
      wx.showToast({
        title: '回复内容不能为空',
        icon: 'none'
      });
      return;
    }
    
    try {
      const comment = {
        studyGardenId: this.data.studyGardenId,
        content: content.trim(),
        parentId: commentId,  // 设置父评论ID
        type: 'study'  // 标记为学习园地评论
      };
      
      const result = await api.addComment(comment);
      
      if (result && (result.code === 0 || result.code === 200)) {
        wx.showToast({
          title: '回复成功',
          icon: 'success'
        });
        
        // 刷新评论列表
        this.refreshStudyGardenComments();
      } else {
        wx.showToast({
          title: result.message || '回复失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('回复失败:', error);
      wx.showToast({
        title: '回复失败，请重试',
        icon: 'none'
      });
    }
  },
  
  // 查看全部回复
  viewAllReplies(e) {
    const commentId = e.currentTarget.dataset.id;
    wx.showLoading({
      title: '加载中...',
    });
    
    api.getCommentReplies(commentId, 1, 50).then(res => {
      wx.hideLoading();
      
      if (res && (res.code === 0 || res.code === 200)) {
        const replyData = res.data || {};
        const replyList = replyData.comments || [];
        
        // 显示回复列表的详情
        wx.showModal({
          title: '全部回复',
          content: replyList.map(item => 
            `${item.comment.userName || '未知用户'}${item.comment.replyToUserName ? ' 回复 ' + item.comment.replyToUserName : ''}: ${item.comment.content}`
          ).join('\n\n') || '暂无回复',
          showCancel: false
        });
      } else {
        wx.showToast({
          title: res.message || '获取回复失败',
          icon: 'none'
        });
      }
    }).catch(err => {
      wx.hideLoading();
      console.error('获取回复失败:', err);
      wx.showToast({
        title: '获取回复失败，请重试',
        icon: 'none'
      });
    });
  },
  
  // 格式化时间
  formatTime(dateStr) {
    if (!dateStr) return '';
    const date = new Date(dateStr);
    const year = date.getFullYear();
    const month = (date.getMonth() + 1).toString().padStart(2, '0');
    const day = date.getDate().toString().padStart(2, '0');
    return `${year}-${month}-${day}`;
  },

  // 显示发表心得表单
  showPostForm() {
    wx.showModal({
      title: '发表学习心得',
      placeholderText: '请输入你的学习心得...',
      editable: true,
      success: (res) => {
        if (res.confirm && res.content) {
          this.postComment(res.content);
        }
      }
    });
  },
  
  // 发表评论
  async postComment(content) {
    if (!content.trim()) {
      wx.showToast({
        title: '评论内容不能为空',
        icon: 'none'
      });
      return;
    }
    
    try {
      const comment = {
        studyGardenId: this.data.studyGardenId,
        content: content.trim(),
        type: 'study' // 标记为学习园地评论
      };
      
      const result = await api.addComment(comment);
      
      if (result && (result.code === 0 || result.code === 200)) {
        wx.showToast({
          title: '发表成功',
          icon: 'success'
        });
        
        // 刷新评论列表
        this.refreshStudyGardenComments();
      } else {
        wx.showToast({
          title: result.message || '发表失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('发表评论失败:', error);
      wx.showToast({
        title: '发表失败，请重试',
        icon: 'none'
      });
    }
  },

  // 跳转到学院详情
  goToSchoolDetail(e) {
    const schoolId = e.currentTarget.dataset.id;
    wx.navigateTo({
      url: `/pages/school/detail?id=${schoolId}`
    });
  },

  // 地图子标签切换
  switchMapTab(e) {
    const tab = e.currentTarget.dataset.tab;
    this.setData({
      mapSubTab: tab
    });
    // 根据不同标签加载不同数据
    switch (tab) {
      case 'heatmap':
        this.loadUserMarkers(); // 保证每次切换都加载
        break;
      case 'distribution':
        this.loadRegionData();
        break;
      case 'gender':
        this.loadGenderData();
        // 同时加载用户列表数据
        this.loadUserList();
        break;
    }
  },

  // 刷新地图数据
  refreshMapData() {
    const { mapSubTab } = this.data;
    switch (mapSubTab) {
      case 'heatmap':
        this.loadUserMarkers(); // 修改为调用新的地图数据加载函数
        break;
      case 'distribution':
        this.loadRegionData();
        break;
      case 'gender':
        this.loadGenderData();
        // 同时刷新用户列表数据
        this.loadUserList();
        break;
    }
  },

  // 加载热力图数据
  loadHeatmapData() {
    // 这里可以调用API获取热力图数据
    console.log('加载热力图数据');
  },

  // 加载地区分布数据
  loadRegionData() {
    switch (this.data.currentRegionLevel) {
      case 'province':
        this.loadProvinceData();
        break;
      case 'city':
        this.loadCityData(this.data.currentProvinceId);
        break;
      case 'district':
        this.loadDistrictData(this.data.currentCityId);
        break;
    }
  },

  // 加载省份数据
  loadProvinceData() {
    wx.showLoading({ title: '加载数据中...' });

    wx.request({
      url: 'http://localhost:8080/api/addresses/provinceUser',
      method: 'GET',
      success: (res) => {
        console.log('省份数据:', res.data);

        if (res.data.code === 200 && res.data.data) {
          const provinces = res.data.data;
          // 计算总用户数和百分比
          const totalUsers = provinces.reduce((sum, item) => sum + (item.userCount || 0), 0);

          // 格式化数据
          const regionData = provinces.map(item => {
            const count = item.userCount || 0;
            const percentage = totalUsers > 0 ? Math.round((count / totalUsers) * 100) : 0;
            return {
              id: item.regionId,
              name: item.regionName,
              count: count,
              percentage: percentage,
              latitude: item.latitude,
              longitude: item.longitude
            };
          });

          // 按用户数量排序
          regionData.sort((a, b) => b.count - a.count);

          this.setData({
            regionData,
            totalUsers,
            currentRegionLevel: 'province',
            breadcrumbs: [],
            regionLevelIndex: 0
          });
        } else {
          wx.showToast({
            title: '获取省份数据失败',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('请求省份数据失败:', err);
        wx.showToast({
          title: '网络请求失败',
          icon: 'none'
        });
      },
      complete: () => {
        wx.hideLoading();
      }
    });
  },

  // 加载城市数据
  loadCityData(provinceId) {
    if (!provinceId) {
      wx.showToast({
        title: '省份ID无效',
        icon: 'none'
      });
      return;
    }

    wx.showLoading({ title: '加载数据中...' });

    wx.request({
      url: `http://localhost:8080/api/addresses/cityUser?provinceId=${provinceId}`,
      method: 'GET',
      success: (res) => {
        console.log('城市数据:', res.data);

        if (res.data.code === 200 && res.data.data) {
          const cities = res.data.data;
          // 计算总用户数和百分比
          const totalUsers = cities.reduce((sum, item) => sum + (item.userCount || 0), 0);

          // 格式化数据
          const regionData = cities.map(item => {
            const count = item.userCount || 0;
            const percentage = totalUsers > 0 ? Math.round((count / totalUsers) * 100) : 0;
            return {
              id: item.regionId,
              name: item.regionName,
              count: count,
              percentage: percentage,
              latitude: item.latitude,
              longitude: item.longitude
            };
          });

          // 按用户数量排序
          regionData.sort((a, b) => b.count - a.count);

          this.setData({
            regionData,
            totalUsers,
            currentRegionLevel: 'city',
            regionLevelIndex: 1
          });
        } else {
          wx.showToast({
            title: '获取城市数据失败',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('请求城市数据失败:', err);
        wx.showToast({
          title: '网络请求失败',
          icon: 'none'
        });
      },
      complete: () => {
        wx.hideLoading();
      }
    });
  },

  // 加载区县数据
  loadDistrictData(cityId) {
    if (!cityId) {
      wx.showToast({
        title: '城市ID无效',
        icon: 'none'
      });
      return;
    }

    wx.showLoading({ title: '加载数据中...' });

    wx.request({
      url: `http://localhost:8080/api/addresses/districtUser?cityId=${cityId}`,
      method: 'GET',
      success: (res) => {
        console.log('区县数据:', res.data);

        if (res.data.code === 200 && res.data.data) {
          const districts = res.data.data;
          // 计算总用户数和百分比
          const totalUsers = districts.reduce((sum, item) => sum + (item.userCount || 0), 0);

          // 格式化数据
          const regionData = districts.map(item => {
            const count = item.userCount || 0;
            const percentage = totalUsers > 0 ? Math.round((count / totalUsers) * 100) : 0;
            return {
              id: item.regionId,
              name: item.regionName,
              count: count,
              percentage: percentage,
              latitude: item.latitude,
              longitude: item.longitude
            };
          });

          // 按用户数量排序
          regionData.sort((a, b) => b.count - a.count);

          this.setData({
            regionData,
            totalUsers,
            currentRegionLevel: 'district',
            regionLevelIndex: 2
          });
        } else {
          wx.showToast({
            title: '获取区县数据失败',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('请求区县数据失败:', err);
        wx.showToast({
          title: '网络请求失败',
          icon: 'none'
        });
      },
      complete: () => {
        wx.hideLoading();
      }
    });
  },

  // 点击地区条目，进入下一级
  tapRegionItem(e) {
    const item = e.currentTarget.dataset.item;
    console.log('点击地区项:', item);

    if (!item || !item.id) return;

    // 在地图上标记该区域
    this.showRegionOnMap(item);

    switch (this.data.currentRegionLevel) {
      case 'province':
        // 设置当前省份并加载该省份的城市数据
        this.setData({
          currentProvinceId: item.id,
          currentProvinceName: item.name,
          breadcrumbs: [{
            level: 'province',
            name: item.name,
            id: item.id
          }]
        });
        this.loadCityData(item.id);
        break;

      case 'city':
        // 设置当前城市并加载该城市的区县数据
        this.setData({
          currentCityId: item.id,
          currentCityName: item.name,
          breadcrumbs: this.data.breadcrumbs.concat([{
            level: 'city',
            name: item.name,
            id: item.id
          }])
        });
        this.loadDistrictData(item.id);
        break;

      case 'district':
        // 区县是最后一级，显示该区县的用户列表
        this.loadDistrictUsers(item.id, item.name);
        break;
    }
  },

  // 在地图上标记显示选中的地区
  showRegionOnMap(region) {
    if (!region || !region.latitude || !region.longitude) {
      console.log('地区数据不包含经纬度信息');
      return;
    }

    // 切换到地图标签页
    this.setData({
      currentTab: 'map',
      mapSubTab: 'heatmap',
      latitude: region.latitude,
      longitude: region.longitude
    });

    // 创建临时标记
    const tempMarker = {
      id: 999,
      latitude: region.latitude,
      longitude: region.longitude,
      width: 40,
      height: 40,
      iconPath: '/images/marker_highlight.png', // 需要一个高亮的图标
      callout: {
        content: `${region.name}: ${region.count}人`,
        color: '#FFFFFF',
        fontSize: 14,
        borderRadius: 6,
        bgColor: '#ff3b30',
        padding: 8,
        display: 'ALWAYS'
      }
    };

    // 添加临时标记并设置定时器移除它
    this.setData({
      markers: [tempMarker]
    });

    // 移动地图到该点
    this.mapCtx.moveToLocation({
      latitude: region.latitude,
      longitude: region.longitude
    });

    // 2秒后重新加载全部标记
    setTimeout(() => {
      this.loadUserMarkers();
    }, 2000);

    // 显示提示
    wx.showToast({
      title: `已定位到${region.name}`,
      icon: 'success'
    });
  },

  // 加载区县用户列表
  loadDistrictUsers(districtId, districtName) {
    wx.showToast({
      title: `加载${districtName}的用户列表`,
      icon: 'none'
    });

    // 实际接口调用可以在这里实现
    // wx.request({
    //   url: `http://localhost:8080/api/addresses/district/users?districtId=${districtId}`,
    //   success: (res) => {
    //     // 处理用户列表数据
    //   }
    // });
  },

  // 面包屑导航点击
  tapBreadcrumb(e) {
    const level = e.currentTarget.dataset.level;
    const id = e.currentTarget.dataset.id;

    if (level === 'province') {
      // 回到省份级别
      if (this.data.currentRegionLevel !== 'province') {
        this.setData({
          breadcrumbs: this.data.breadcrumbs.slice(0, 1),
          currentRegionLevel: 'province'
        });
        this.loadProvinceData();
      }
    } else if (level === 'city') {
      // 回到城市级别
      if (this.data.currentRegionLevel === 'district') {
        this.setData({
          breadcrumbs: this.data.breadcrumbs.slice(0, 2),
          currentRegionLevel: 'city'
        });
        this.loadCityData(id);
      }
    }
  },

  // 选择地区级别(直接切换省市区视图)
  selectRegionLevel(e) {
    const regionLevelIndex = Number(e.detail.value);
    this.setData({ regionLevelIndex });

    // 根据选择的级别加载数据
    switch (regionLevelIndex) {
      case 0: // 省份
        this.setData({ currentRegionLevel: 'province' });
        this.loadProvinceData();
        break;
      case 1: // 城市
        if (this.data.currentProvinceId) {
          this.setData({ currentRegionLevel: 'city' });
          this.loadCityData(this.data.currentProvinceId);
        } else {
          wx.showToast({
            title: '请先选择省份',
            icon: 'none'
          });
          this.setData({ regionLevelIndex: 0 });
          this.loadProvinceData();
        }
        break;
      case 2: // 区县
        if (this.data.currentCityId) {
          this.setData({ currentRegionLevel: 'district' });
          this.loadDistrictData(this.data.currentCityId);
        } else {
          wx.showToast({
            title: '请先选择城市',
            icon: 'none'
          });
          if (this.data.currentProvinceId) {
            this.setData({ regionLevelIndex: 1 });
            this.loadCityData(this.data.currentProvinceId);
          } else {
            this.setData({ regionLevelIndex: 0 });
            this.loadProvinceData();
          }
        }
        break;
    }
  },

  // 加载性别比例数据
  loadGenderData() {
    wx.showLoading({
      title: '加载性别数据...'
    });

    wx.request({
      url: 'http://localhost:8080/api/userCollections/gender',
      method: 'GET',
      success: (res) => {
        console.log('性别比例数据:', res.data);
        
        if (res.data.code === 200 && res.data.data) {
          const data = res.data.data;
          const malePercentage = Math.round(data.malePercent);
          const femalePercentage = Math.round(data.femalePercent);
          
          this.setData({
            'genderData.male': malePercentage,
            'genderData.female': femalePercentage,
            'genderData.maleCount': data.maleCount,
            'genderData.femaleCount': data.femaleCount,
            'genderData.total': data.total
          });

          // 更新环形图样式
          this.updateGenderDonutStyle(malePercentage, femalePercentage);
          
          console.log('性别比例数据更新成功');
        } else {
          console.error('获取性别比例数据失败:', res.data.message);
          wx.showToast({
            title: '获取性别数据失败',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('请求性别比例数据失败:', err);
        wx.showToast({
          title: '网络请求失败',
          icon: 'none'
        });
      },
      complete: () => {
        wx.hideLoading();
      }
    });
  },

  // 更新性别比例环形图样式
  updateGenderDonutStyle(malePercentage, femalePercentage) {
    // 在小程序中，我们不能直接操作DOM或CSS变量
    // 而是通过设置内联样式的方式来实现
    const donutBackground = `conic-gradient(#ff3b30 0% ${femalePercentage}%, #3a86ff ${femalePercentage}% 100%)`;

    this.setData({
      donutStyle: `background: ${donutBackground};`
    });
  },

  // 显示用户详情
  showUserDetail(e) {
    const userId = e.currentTarget.dataset.id;
    wx.showToast({
      title: `查看用户ID: ${userId}`,
      icon: 'none'
    });
    // 这里可以跳转到用户详情页面
  },

  // 显示筛选器
  showFilter() {
    wx.showToast({
      title: '筛选功能开发中',
      icon: 'none'
    });
  },
  
  // 加载用户列表数据
  loadUserList() {
    wx.showLoading({
      title: '加载用户列表...'
    });

    wx.request({
      url: 'http://localhost:8080/api/userCollections/userList',
      method: 'GET',
      success: (res) => {
        console.log('用户列表数据:', res.data);
        
        if (res.data.code === 200 && res.data.data) {
          const userListData = res.data.data.map(user => {
            // 将性别数值转换为字符串标识
            const gender = user.gender === 0 ? 'male' : 'female';
            
            // 尝试从地址中提取省份和城市
            let province = '';
            let city = '';
            
            if (user.address) {
              const addressParts = user.address.split(/[省市区县]/).filter(part => part);
              if (addressParts.length >= 2) {
                province = addressParts[0] + '省';
                city = addressParts[1] + '市';
              } else if (addressParts.length === 1) {
                city = addressParts[0];
              } else {
                province = user.address;
              }
            }
            
            return {
              id: user.id,
              name: user.name || '未知用户',
              avatar: user.avatar || '/images/default-avatar.png',
              gender: gender,
              province: province,
              city: city,
              activity: user.points || 0 // 使用积分作为活跃度
            };
          });
          
          this.setData({
            userList: userListData
          });
          
          console.log('用户列表数据更新成功');
        } else {
          console.error('获取用户列表数据失败:', res.data.message);
          wx.showToast({
            title: '获取用户列表失败',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('请求用户列表数据失败:', err);
        wx.showToast({
          title: '网络请求失败',
          icon: 'none'
        });
      },
      complete: () => {
        wx.hideLoading();
      }
    });
  },

  // 加载用户标记点
  loadUserMarkers() {
    // 显示加载中提示
    wx.showLoading({
      title: '加载地图数据中',
    });

    // 请求后端API获取地址分布数据
    wx.request({
      url: 'http://localhost:8080/api/addresses/district',
      method: 'GET',
      success: (res) => {
        console.log('地址分布数据:', res.data);

        if (res.data.code === 200 && res.data.data) {
          const locationData = res.data.data;

          // 计算用户总数
          const totalUsers = locationData.reduce((sum, location) => {
            return sum + (location.count || 0);
          }, 0);

          // 转换为地图标记
          const markers = locationData.map((location, index) => {
            return {
              id: index,
              latitude: location.latitude,
              longitude: location.longitude,
              width: 30,
              height: 30,
              iconPath: '/images/marker.png',
              callout: {
                content: `${location.name}: ${location.count}人`,
                color: '#FFFFFF',
                fontSize: 12,
                borderRadius: 4,
                bgColor: '#3a86ff',
                padding: 5,
                display: 'ALWAYS'
              }
            };
          });

          this.setData({
            markers,
            totalUsers
          });

          try {
            // 调整地图视野以包含所有标记点
            if (this.mapCtx && markers.length > 0) {
              this.mapCtx.includePoints({
                points: markers.map(marker => ({
                  latitude: marker.latitude,
                  longitude: marker.longitude
                })),
                padding: [50, 50, 50, 50]
              });
            }
          } catch (e) {
            console.error('地图操作错误:', e);
          }
        } else {
          wx.showToast({
            title: '获取地址数据失败',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('请求地址数据失败:', err);
        wx.showToast({
          title: '网络请求失败',
          icon: 'none'
        });
      },
      complete: () => {
        wx.hideLoading();
      }
    });
  },

  // 清空搜索
  clearSearch() {
    this.setData({
      keyword: '',
      pageNum: 1
    }, () => {
      this.loadSchoolRanking();
    });
  },

  // 初始化腾讯地图
  /**
   * 初始化腾讯地图
   * 1. 设置加载状态和地图中心点坐标
   * 2. 创建地图上下文
   * 3. 加载初始标记点，完成后取消加载状态
   */
  initTencentMap() {
    this.setData({
      isLoading: true,
      mapCenter: {
        longitude: 116.404,
        latitude: 39.915
      }
    });

    // 创建地图上下文
    this.mapCtx = wx.createMapContext('tencentMap', this);

    // 加载初始标记点
    this.loadMapMarkers(this.data.mapCenter).then(() => {
      this.setData({ isLoading: false });
    });
  },

  // 加载地图标记点
  async loadMapMarkers(center) {
    try {
      // 这里使用腾讯地图API获取真实数据
      const result = await wx.request({
        url: 'https://apis.map.qq.com/ws/geocoder/v1/',
        data: {
          location: `${center.latitude},${center.longitude}`,
          key: this.data.mapConfig.key,
          get_poi: 1,
          poi_options: 'page_size=20'
        }
      });
      // console.log( result.data.pois)
      // if (result.data.status === 0) {
      //   const markers = result.data.pois.map(poi => ({
      //     id: poi.id,
      //     latitude: poi.location.lat,
      //     longitude: poi.location.lng,
      //     iconPath: '/images/marker.png',
      //     width: 30,
      //     height: 30,
      //     callout: {
      //       content: poi.title,
      //       color: '#333',
      //       fontSize: 14,
      //       borderRadius: 10,
      //       bgColor: '#fff',
      //       padding: 5,
      //       display: 'ALWAYS'
      //     }
      //   }));

      //   this.setData({ markers });
      // } else {
      //   throw new Error(result.data.message);
      // }
    } catch (error) {
      console.error('加载地图标记点失败:', error);
      wx.showToast({
        title: '加载地图数据失败',
        icon: 'none'
      });
    }
  },

  // 地图区域变化事件
  onMapRegionChange(e) {
    if (e.type === 'end' && e.causedBy === 'drag') {
      // 用户拖动地图后更新地图中心点坐标
      this.mapCtx.getCenterLocation({
        success: (res) => {
          this.setData({
            latitude: res.latitude,
            longitude: res.longitude
          });
        }
      });
    }
  },

  // 地图点击事件
  onMapTap(e) {
    console.log('地图点击事件:', e);
    // 如果点击的是标记点
    if (e.markerId !== undefined) {
      const marker = this.data.markers.find(m => m.id === e.markerId);
      if (marker) {
        wx.showToast({
          title: marker.callout.content,
          icon: 'none',
          duration: 2000
        });
      }
    }
  },

  // 添加地图控件方法
  addMapControls() {
    if (!this.mapCtx) return;

    // 添加回到中心点的控件
    this.mapCtx.addControl({
      id: 1,
      iconPath: '/images/location.png',
      position: {
        left: 10,
        top: 10,
        width: 40,
        height: 40
      },
      clickable: true
    });
  }
});
